A Guide to Leaflet

Introduction

Leaflet is one of the most popular open-source JavaScript libraries for interactive maps. It’s used by websites ranging from The New York Times and The Washington Post to GitHub and Flickr, as well as GIS specialists like OpenStreetMap, Mapbox, and CartoDB.

This R package makes it easy to integrate and control Leaflet maps in R.

library(tidyverse)     # for data cleaning and plotting
library(gplots)        # for col2hex() function
library(RColorBrewer)  # for color palettes
library(sf)            # for working with spatial data
library(leaflet)       # for highly customizable mapping
library(carData)       # for Minneapolis police stops data
library(tidytuesdayR)  # for bigfoot data 
library(ggthemes)      # for more themes (including theme_map())
library(htmltools)
theme_set(theme_minimal())

Features

Interactive panning/zooming Compose maps using arbitrary combinations of: ·Map tiles ·Markers ·Polygons ·Lines ·Popups ·GeoJSON Create maps right from the R console or RStudio Embed maps in knitr/R Markdown documents and Shiny apps Easily render spatial objects from the sp or sf packages, or data frames with latitude/longitude columns Use map bounds and mouse events to drive Shiny logic Display maps in non spherical mercator projections *Augment map features using chosen plugins from leaflet plugins repository

Base maps

We are gonna start from the bottom layer up. The first thing to look it is the base maps. This means, what will be behind your points or shapes. There are many options and they are super easy to load in. We can start off with the basic basic map, simple blue ocean and white land, if you zoom in there will be more detials

leaflet() %>% 
  addTiles()

We can also start the map zoomed in on a specific area using latitude and longitude and the setView() function

Here is Saint Paul MN, now look up your hometown and practice putting in the coordinates.

leaflet() %>% 
  addTiles() %>% 
  setView(lng = -93.093124, lat = 44.949642, zoom = 12)

hometown <- leaflet() %>% 
  setView(lng = -93.093124, lat = 44.949642, zoom = 12) %>% 
    addTiles()

There are many other base maps you can use in leaflet! To get different base maps use the function addProviderTiles(), you will need to know the name of the basemap Here are some examples:

hometown %>% 
    addProviderTiles(providers$CartoDB.Positron) 

hometown %>% 
    addProviderTiles(providers$Stamen.Watercolor)

hometown %>% 
    addProviderTiles(providers$CartoDB.DarkMatterNoLabels)

To get the full list of base maps available through this function click here: http://leaflet-extras.github.io/leaflet-providers/preview/index.html

If you want to use any other ones from this website just replace what is after the $ in the addProviderTiles().

Let say you really like the water color base map but there aren’t any labels, you can add layers to your base maps. Here I have layered the water color with the light grey base map that had labels. As long as you set the one on top to have a lower opacity you can see both!

hometown %>% addProviderTiles(providers$Stamen.Watercolor) %>%
  addProviderTiles(providers$CartoDB.Positron,
    options = providerTileOptions(opacity = 0.5)) 

Try experimenting with the opacity and different layering techniques with base maps that you like!

#hometown %>% addProviderTiles(providers$__________) %>%
  #addProviderTiles(providers$______,
    #options = providerTileOptions(opacity = ___)) 

Markers

Now we have our base map figured out we can add markers. To do that, we will needed data. The best data to use is data where the observations should have a latitude and longitude variable. This makes for a smooth process when adding markers.

tuesdata <- tidytuesdayR::tt_load('2022-09-13') #Loading in data from a tidy tuesday that has geographical points

## 
##  Downloading file 1 of 1: `bigfoot.csv`

bigfoot <- tuesdata$bigfoot

First lets practice adding all the data.

leaflet(data = bigfoot) %>% addProviderTiles(providers$Stamen.Watercolor) %>%
  addProviderTiles(providers$CartoDB.Positron,
    options = providerTileOptions(opacity = 0.5))  %>%
  addMarkers(~longitude, ~latitude)

If R is running slowly now its because there are so many data points. It is best to filter out observations that you need before making a map.

bigfootsub <- bigfoot %>% 
  filter(state == "California") %>% #Narrowing down to a state, pick any state you want! 
  filter(season == "Summer") # Also only looking at bigfoot sightings during one season 

leaflet(data = bigfootsub) %>% addProviderTiles(providers$Stamen.Watercolor) %>%
  addProviderTiles(providers$CartoDB.Positron,
    options = providerTileOptions(opacity = 0.5))  %>%
  addMarkers(~longitude, ~latitude)

With less points the software runs far smoother. Now we can add some fun things!

Plain Markers and Popups

Not only can you add labels to these points but with leaflet you can add popups

leaflet(data = bigfootsub) %>% 
  addProviderTiles(providers$Stamen.Watercolor) %>%
  addProviderTiles(providers$CartoDB.Positron,
    options = providerTileOptions(opacity = 0.5)) %>% 
  addMarkers(~longitude, ~latitude,label = ~date, popup = ~location_details) # label means what will appear when you hover over the point and popup means what will appear when you click on a point

Awesome Markers

Awesome markers allow you to change the color of the marker dependent on a variable

# After choosing temperature_high to be my variable I am visualizing I am going to filter out any observations that do not have a value for temperature_high
bftemp <- bigfootsub %>% 
  filter(temperature_high != "NA")

#Then we will need to assign values of temperature_high  to colors creating a getColor function 

getColor <- function(bftemp) {
  sapply(bftemp$temperature_high, function(temperature_high){ # Creating a function using the bftemp data and temperature_high data 
  if(temperature_high <= 68) { #creating an if else statement to make the marker a certain color based on temperature 
    "blue"
  } else if(temperature_high >= 69) {
    "red"
  } else {
    "green"
  } })
}

icons <- awesomeIcons(
  icon = 'ios-close',
  iconColor = 'pink', #Controls color of middle x 
  library = 'ion',
  markerColor = getColor(bftemp) #Calls the function 
)

leaflet(bftemp) %>% 
  addProviderTiles(providers$Stamen.Watercolor) %>%
  addProviderTiles(providers$CartoDB.Positron,
    options = providerTileOptions(opacity = 0.5))  %>% 
  addAwesomeMarkers(~longitude, ~latitude,label = ~date, popup = ~location_details, icon = icons) #make sure to set the icons

Color

Colors in leaflet need to be in “hex” form. Thus, instead of using color directly as in ggplot, we will use color functions which could help us create “hex” color. The color function returns a palette function that can be passed a vector of input values, and it’ll return a vector of colors in #RRGGBB(AA) format.There are currently three color functions for dealing with continuous input: colorNumeric, colorBin, and colorQuantile; and one for categorical input, colorFactor.

# load continuous dataset
data_site <- 
  "https://www.macalester.edu/~dshuman1/data/112/2014-Q4-Trips-History-Data.rds" 
Trips <- readRDS(gzcon(url(data_site)))
Stations<-read_csv("http://www.macalester.edu/~dshuman1/data/112/DC-Stations.csv")

departSta <- Trips %>%
  left_join(Stations, by = c("sstation" = "name")) %>%
  group_by(lat, long) %>%
  summarise(EventsCount = n())

Create Color Palette

To create a color palette(palette function): you call 1) the color function with colors (palette) you want to use and 2) optionally, the domain (the specific variable you want to include) that are expected. The color function (i.e. colorNumeric) returns a function that maps a variable’s values to colors in the given palette, in one of the examples below is “Blues”. So, pal() is a function. We can then use that function inside other functions where you want colors.

Notice that though the domain arguement is optional, it’s important to provide a non-NULL value for domain if you use a palette function multiple times across different data so the scaling between data and colors is consistent.

# Call the color function (colorNumeric) to create a new palette function
pal <- colorNumeric(c("red", "green", "blue"), 1:10)
# Pass the palette function a data vector to get the corresponding colors
pal(c(1,6,9))

## [1] "#FF0000" "#52E74B" "#6854D8"

# create another color palette function with the range of inputs (i.e. domain) 
palDomain <- colorNumeric(
  palette = "Blues",
  domain = departSta$EventsCount)
# Show the corresponding colors
head(palDomain(departSta$EventsCount))

## [1] "#F5FAFE" "#EFF6FC" "#F2F8FD" "#F5F9FE" "#EEF5FC" "#EFF6FC"

Common Parameters

The palette argument specifies the colors to map the data. Here shows the four most common forms.

• RColorBrewer
• viridis
• RGB or Named the colors
• A function that receives a single value between 0 and 1 and returns a color

#RColorBrewer 
palBre <- colorNumeric(
  palette = "RdYlBu",
  domain = departSta$EventsCount)

#viridis
palVir <- colorNumeric(
  palette = "magma",
  domain = departSta$EventsCount)

#RGB or Named the colors: palette(), c("#000000", "#0000FF", "#FFFFFF"), topo.colors(10) etc

#A function that receives a single value between 0 and 1 and returns a color: colorRamp(c("#000000", "#FFFFFF"), interpolate="spline") etc

Continuous Data

To color continuous data, there are three available color functions: colorNumeric, colorBin, and colorQuantile.

#Continuous input, continuous colors (colorNumeric)
palConC <- colorNumeric(
  palette = "RdYlBu",
  domain = departSta$EventsCount)

#Continuous input, discrete colors (colorBin and colorQuantile)

# colorBin:slicing the input domain up by value(bin)
palBin<-colorBin("Blues", departSta$EventsCount, 5, pretty = FALSE)

#colorQuantile: slicing the input domain into subsets with equal numbers of observations (by quantile)
palQuan <- colorQuantile("Blues", departSta$EventsCount, n = 7)

Continuous Data Example

# colorBin
leaflet(data = departSta) %>%
  addProviderTiles(providers$CartoDB.DarkMatter) %>%
  addProviderTiles(providers$Stamen.TonerLines,
                   options = providerTileOptions(opacity = 0.35)) %>%
  addProviderTiles(providers$Stamen.TonerLabels) %>%
    addCircles(lng = ~long,
             lat = ~lat,
            #stroke width in pixels
             weight = 10,
            #changes transparency, like alpha in ggplot
             opacity = 1,
             color = ~palBin(EventsCount))

# colorQuantile
leaflet(data = departSta) %>%
  addProviderTiles(providers$CartoDB.DarkMatter) %>%
  addProviderTiles(providers$Stamen.TonerLines,
                   options = providerTileOptions(opacity = 0.35)) %>%
  addProviderTiles(providers$Stamen.TonerLabels) %>%
    addCircles(lng = ~long,
             lat = ~lat,
            #stroke width in pixels
             weight = 10,
            #changes transparency, like alpha in ggplot
             opacity = 1,
             color = ~palQuan(EventsCount))

Categorical Data

For categorical data, you will use the colorFactor function. If you want to specify the input domain, you can either by passing a factor or character vector to domain, or by providing levels directly using the levels parameter (in which case the domain will be ignored).

#Domain
palFacD<-colorFactor(palette = "Blues", MplsStops$problem)
#Level
palFacL<-colorFactor(topo.colors(5),levels = MplsStops$problem)

Categorical Example

leaflet(data = MplsStops) %>%
  addProviderTiles(providers$CartoDB.Positron) %>%
  addCircleMarkers(lng = ~long,
             lat = ~lat,
             weight = 1,
             opacity = 1,
             stroke = TRUE,
             color = ~palFacL(problem))

Lines and Shape

For creating a rectangle, the four vector arguments indicating its four angles are required.While the Polygons and Polylines are more flexible and can be inferred from the data object.

#rectangle
leaflet(data = departSta) %>%
  addProviderTiles(providers$CartoDB.DarkMatter) %>%
  addProviderTiles(providers$Stamen.TonerLines,
                   options = providerTileOptions(opacity = 0.35)) %>%
  addProviderTiles(providers$Stamen.TonerLabels) %>%
  addCircles(
    lng = ~ long,
    lat = ~ lat,
    #stroke width in pixels
    weight = 10,
    #changes transparency, like alpha in ggplot
    opacity = 1,
    color = ~ palQuan(EventsCount)
  ) %>%
  addRectangles(
    lng1 = -77.20250,
    lat1 =38.80111,
    lng2 =-76.93186,
    lat2 = 39.12351,
    fillColor = "transparent"
  )

#Polygons and Polylines
leaflet(data = departSta) %>%
  addProviderTiles(providers$CartoDB.DarkMatter) %>%
  addProviderTiles(providers$Stamen.TonerLines,
                   options = providerTileOptions(opacity = 0.35)) %>%
  addProviderTiles(providers$Stamen.TonerLabels) %>%
  addPolygons(
    lng = ~ long,
    lat = ~ lat,
    # set the opacity of the outline
    opacity = 1,
    # set the stroke width in pixels
    weight = 1,
    # set the fill opacity
    fillOpacity = 0.6
  )

Legend

addLegend() function is aware of the different types of palette functions, and will create an appropriate default rendering for each type.Thus, you do not need to edit it manully when changing the domain or other scales.

leaflet(data = MplsStops) %>%
  addProviderTiles(providers$CartoDB.Positron) %>%
  addCircleMarkers(lng = ~long,
             lat = ~lat,
             weight = 1,
             opacity = 1,
             stroke = TRUE,
             color = ~palFacL(problem)) %>% 
    addLegend(position = "bottomleft", 
            pal = palFacL,
            values = ~problem,
             title = "Type of Stops") 

Choropleth Map

#In this case, we’ll use the geojsonio package to load the data into sp objects, which will let us easily manipulate the geographic features, and their properties, in R.

states <- geojsonio::geojson_read("https://rstudio.github.io/leaflet/json/us-states.geojson", what = "sp")

bins <- c(0, 10, 20, 50, 100, 200, 500, 1000, Inf)
pal <- colorBin("YlOrRd", domain = states$density, bins = bins)

# Creating labels
labels <- sprintf(
  "<strong>%s</strong><br/>%g people / mi<sup>2</sup>",
  states$name, states$density
) %>% lapply(htmltools::HTML)

leaflet(states) %>%
  setView(-96, 37.8, 4) %>%
  addProviderTiles("MapBox", options = providerTileOptions(
    id = "mapbox.light",
    accessToken = Sys.getenv('MAPBOX_ACCESS_TOKEN'))) %>% 
  addPolygons(
    fillColor = ~pal(density),
    weight = 2,
    opacity = 1,
    color = "white",
    dashArray = "3",
    fillOpacity = 0.7,
    # hightlight the polygon when curse over it
    highlightOptions = highlightOptions(
      weight = 5,
      color = "#666",
      dashArray = "",
      fillOpacity = 0.7,
      bringToFront = TRUE),
    # add labels
    label = labels,
    labelOptions = labelOptions(
      style = list("font-weight" = "normal", padding = "3px 8px"),
      textsize = "15px",
      direction = "auto"))